#pragma once
#include "service_registry.h"
#include "load_balancer.h"
#include "grpc_client_pool.h"
#include "framework/request.h"
#include "framework/response.h"
#include <memory>
#include <thread>
#include <atomic>
#include <functional>

namespace cpp_backend {
namespace framework {

/**
 * @brief 服务总线V2 - 基于gRPC的RPC调用
 * 
 * 替代原ServiceBus的进程内调用，提供相同API接口
 * 
 * 核心功能：
 * - 服务发现（通过ServiceRegistry）
 * - 负载均衡（通过LoadBalancer）
 * - gRPC调用（通过GrpcClientPool）
 * - 健康检查（定期检查服务实例）
 */
class ServiceBusV2 {
public:
    /**
     * @brief 获取单例
     */
    static ServiceBusV2& Instance() {
        static ServiceBusV2 instance;
        return instance;
    }
    
    /**
     * @brief 初始化（必须在使用前调用）
     * @param redis_pool Redis连接池（用于服务注册中心）
     */
    void Initialize(database::RedisPool* redis_pool);
    
    /**
     * @brief 关闭
     */
    void Shutdown();
    
    /**
     * @brief 同步RPC调用
     * 
     * API与原ServiceBus完全一致，无需修改上层代码
     * 
     * @param service_name 服务名称 "PingService"
     * @param request 请求对象
     * @return 响应对象
     */
    Response CallService(const std::string& service_name, const Request& request);
    
    /**
     * @brief 异步RPC调用
     * 
     * @param service_name 服务名称
     * @param request 请求对象
     * @param callback 回调函数
     */
    void CallServiceAsync(
        const std::string& service_name,
        const Request& request,
        std::function<void(const Response&)> callback
    );
    
    /**
     * @brief 设置负载均衡策略
     */
    void SetLoadBalanceStrategy(LoadBalancer::Strategy strategy) {
        load_balance_strategy_ = strategy;
    }
    
private:
    ServiceBusV2();
    ~ServiceBusV2();
    
    // 禁止拷贝和移动
    ServiceBusV2(const ServiceBusV2&) = delete;
    ServiceBusV2& operator=(const ServiceBusV2&) = delete;
    
    /**
     * @brief 服务发现
     */
    std::vector<ServiceInstance> discover_service(const std::string& service_name);
    
    /**
     * @brief 负载均衡选择实例
     */
    ServiceInstance select_instance(
        const std::vector<ServiceInstance>& instances,
        const std::string& key = ""
    );
    
    /**
     * @brief gRPC调用
     */
    Response rpc_call(const ServiceInstance& instance, const Request& request);
    
    /**
     * @brief 启动健康检查线程
     */
    void start_health_check_thread();
    
    /**
     * @brief 健康检查循环
     */
    void health_check_loop();
    
    // 核心组件
    std::unique_ptr<ServiceRegistry> registry_;
    std::unique_ptr<LoadBalancer> load_balancer_;
    std::unique_ptr<GrpcClientPool> grpc_client_pool_;
    
    // 配置
    LoadBalancer::Strategy load_balance_strategy_;
    
    // 健康检查
    std::thread health_check_thread_;
    std::atomic<bool> running_;
    
    // 初始化标志
    std::atomic<bool> initialized_;
};

} // namespace framework
} // namespace cpp_backend
